package com.example.archive.controller;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.example.archive.entity.Training;
import com.example.archive.service.TrainingService;
import com.example.archive.config.FileUploadConfig;
import com.example.archive.util.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.io.FileSystemResource;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.List;
import java.util.UUID;

/**
 * 培训资料管理控制器
 * 提供培训资料的上传、下载、审核、删除等功能
 * 支持角色权限控制：普通员工只能查看和下载已发布资料
 * 档案管理员可以上传资料，企业领导可以审核资料
 */
@RestController
@RequestMapping("/api/trainings")
@CrossOrigin
public class TrainingController {
    
    @Autowired
    private TrainingService trainingService;
    
    /**
     * 获取已发布的培训资料（员工查看）
     * 普通员工只能查看已发布状态的培训资料
     * 
     * @return 统一响应格式，包含已发布的培训资料列表
     */
    @GetMapping("/published")
    public Result<List<Training>> getPublishedTrainings() {
        try {
            List<Training> trainings = trainingService.getPublishedTrainings();
            return Result.success(trainings);
        } catch (Exception e) {
            return Result.fail(500, "获取失败：" + e.getMessage());
        }
    }
    
    /**
     * 分页查询培训资料（管理员查看）
     * 管理员和领导可以查看所有状态的培训资料
     * 支持分页查询，包含上传者信息
     * 
     * @param current 当前页码，默认为1
     * @param size 每页大小，默认为10
     * @return 统一响应格式，包含分页查询结果
     */
    @GetMapping("/page")
    public Result<Page<Training>> getTrainingsPage(
            @RequestParam(defaultValue = "1") int current,
            @RequestParam(defaultValue = "10") int size) {
        try {
            Page<Training> page = trainingService.getTrainingsWithUploader(current, size);
            return Result.success(page);
        } catch (Exception e) {
            return Result.fail(500, "获取失败：" + e.getMessage());
        }
    }
    
    /**
     * 上传培训资料
     * 档案管理员可以上传培训资料，上传后状态为草稿，需要企业领导审核
     * 文件会保存到uploads目录，文件名前加UUID防止重名
     * 
     * @param file 上传的文件
     * @param title 培训资料标题
     * @param description 培训资料描述
     * @param uploaderId 上传者用户ID
     * @param status 资料状态，默认为published
     * @return 统一响应格式，包含上传结果
     */
    @PostMapping("/upload")
    public Result<Boolean> uploadTraining(
            @RequestParam("file") MultipartFile file,
            @RequestParam("title") String title,
            @RequestParam("description") String description,
            @RequestParam("uploaderId") Integer uploaderId,
            @RequestParam(value = "status", defaultValue = "published") String status) {
        try {
            // 获取原始文件名
            String fileName = file.getOriginalFilename();
            // 生成唯一文件名，防止重名冲突
            String newFileName = UUID.randomUUID().toString() + "_" + fileName;
            
            // 使用配置类获取上传路径
            String uploadPath = FileUploadConfig.getUploadPath();
            String filePath = FileUploadConfig.getRelativePath(newFileName);
            
            // 创建目标文件并保存
            File targetFile = new File(uploadPath + File.separator + newFileName);
            file.transferTo(targetFile);
            
            // 创建培训资料对象并保存到数据库
            Training training = new Training();
            training.setTitle(title);
            training.setDescription(description);
            training.setFilePath(filePath);
            training.setUploaderId(uploaderId);
            training.setStatus(status);
            
            boolean success = trainingService.uploadTraining(training);
            if (success) {
                return Result.success(true);
            } else {
                return Result.fail(500, "上传失败");
            }
        } catch (Exception e) {
            return Result.fail(500, "上传失败：" + e.getMessage());
        }
    }
    
    /**
     * 审核培训资料
     * 企业领导可以审核档案管理员上传的培训资料
     * 审核通过后状态变为published，驳回后状态变为rejected
     * 
     * @param id 培训资料ID
     * @param status 审核后的状态（published/rejected）
     * @return 统一响应格式，包含审核结果
     */
    @PutMapping("/approve/{id}")
    public Result<Boolean> approveTraining(
            @PathVariable Integer id,
            @RequestParam String status) {
        try {
            boolean success = trainingService.approveTraining(id, status);
            if (success) {
                return Result.success(true);
            } else {
                return Result.fail(500, "审核失败");
            }
        } catch (Exception e) {
            return Result.fail(500, "审核失败：" + e.getMessage());
        }
    }
    
    /**
     * 删除培训资料
     * 企业领导可以删除任何培训资料
     * 档案管理员只能删除自己上传的草稿状态资料
     * 
     * @param id 培训资料ID
     * @return 统一响应格式，包含删除结果
     */
    @DeleteMapping("/{id}")
    public Result<Boolean> deleteTraining(@PathVariable Integer id) {
        try {
            boolean success = trainingService.removeById(id);
            if (success) {
                return Result.success(true);
            } else {
                return Result.fail(500, "删除失败");
            }
        } catch (Exception e) {
            return Result.fail(500, "删除失败：" + e.getMessage());
        }
    }
    
    /**
     * 下载培训资料
     * 只有已发布状态的培训资料才能下载
     * 支持中文文件名，自动去除UUID前缀显示原始文件名
     * 
     * @param id 培训资料ID
     * @return 文件下载响应，如果文件不存在或无权限则返回相应错误状态
     */
    @GetMapping("/download/{id}")
    public ResponseEntity<Resource> downloadTraining(@PathVariable Integer id) {
        try {
            // 根据ID获取培训资料信息
            Training training = trainingService.getById(id);
            if (training == null) {
                return ResponseEntity.notFound().build();
            }
            
            // 检查文件状态，只有已发布的文件才能下载
            if (!"published".equals(training.getStatus())) {
                return ResponseEntity.status(403).build();
            }
            
            // 构建文件路径
            String uploadPath = FileUploadConfig.getUploadPath();
            String fileName = training.getFilePath().replace("uploads" + File.separator, "");
            File file = new File(uploadPath + File.separator + fileName);
            
            // 检查文件是否存在
            if (!file.exists()) {
                return ResponseEntity.notFound().build();
            }
            
            Resource resource = new FileSystemResource(file);
            
            // 获取原始文件名（去掉UUID前缀）
            String originalFileName = fileName;
            if (fileName.contains("_")) {
                originalFileName = fileName.substring(fileName.indexOf("_") + 1);
            }
            
            // URL编码文件名以支持中文
            String encodedFileName;
            try {
                encodedFileName = URLEncoder.encode(originalFileName, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                encodedFileName = originalFileName;
            }
            
            // 返回文件下载响应
            return ResponseEntity.ok()
                    .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename*=UTF-8''" + encodedFileName)
                    .contentType(MediaType.APPLICATION_OCTET_STREAM)
                    .body(resource);
                    
        } catch (Exception e) {
            return ResponseEntity.status(500).build();
        }
    }
} 